home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgramD2.iso / Borland / Borland C++ V5.02 / CLASSSRC.PAK / SYSTEM.CPP < prev    next >
C/C++ Source or Header  |  1997-05-06  |  5KB  |  194 lines
  1. //----------------------------------------------------------------------------
  2. // Borland WinSys Library
  3. // Copyright (c) 1995, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   5.12  $
  6. //
  7. // Implementation of TSystem class.
  8. //----------------------------------------------------------------------------
  9. #include <winsys/pch.h>
  10. #include <winsys/system.h>
  11.  
  12. #if defined(BI_PLAT_WIN32)
  13.  
  14. //
  15. // Return an initialized version info object
  16. //
  17. TSystem::TVersionInfo& TSystem::GetVerInfo()
  18. {
  19.   static TVersionInfo versionInfo;
  20.   return versionInfo;
  21. }
  22.  
  23. //
  24. // Return an initialized system info object
  25. //
  26. TSystem::TSystemInfo& TSystem::GetSystemInfo()
  27. {
  28.   static TSystemInfo systemInfo;
  29.   return systemInfo;
  30. }
  31.  
  32. //
  33. // Return true if the system has exception suport built in and the runtime
  34. // library uses it for stack unwinding support.
  35. //
  36. bool TSystem::SupportsExceptions()
  37. {
  38.   static bool exceptionOK = GetPlatformId() != Win32s;
  39.   return exceptionOK;
  40. }
  41.  
  42. //
  43. // Return true if the system has thread suport built in and the runtime
  44. // library uses it.
  45. //
  46. bool TSystem::SupportsThreads()
  47. {
  48.   static bool threadOK = GetPlatformId() != Win32s;
  49.   return threadOK;
  50. }
  51.  
  52. //
  53. // Return true if the system has suport for per-instance data built in and the
  54. // runtime library uses it.
  55. //
  56. bool TSystem::SupportsInstanceData()
  57. {
  58.   static bool instanceDataOK = GetPlatformId() != Win32s;
  59.   return instanceDataOK;
  60. }
  61.  
  62. #endif  // defined(BI_PLAT_WIN32)
  63.  
  64. //
  65. // Does this OS support a full 3d UI? (Basically, is it Win95?)
  66. //
  67. bool TSystem::Has3dUI()
  68. {
  69. #if defined(BI_PLAT_WIN16)
  70.   return IsWin95() || (IsWoW() && (GetMajorVersion() >= 4));
  71. #else
  72.   return GetVerInfo().GetMajorVersion() >= 4;  // Win95 or NT w/ New Shell
  73. #endif
  74. }
  75.  
  76. #if defined(BI_PLAT_WIN16)
  77.  
  78. //
  79. // Get build numbers for Windows NT or Win32s
  80. // Returns 0 under Win95 (no build numbers provided)
  81. //
  82. uint TSystem::GetBuildNumber() {
  83.  
  84.   uint32 result = GetVersion();
  85.   uint build;
  86.  
  87.   if (result < 0x80000000L)                // Windows NT
  88.     build = HIWORD(result);
  89.   else if (GetMajorVersion() < 4)         // Win32s
  90.     build = HIWORD(result) & ~0x8000;
  91.   else
  92.     build =  0;
  93.  
  94.   return build;
  95. }
  96.  
  97. //
  98. // Return true if the system is win16 WoW under NT.
  99. //
  100. bool TSystem::IsWoW()
  101. {
  102.   static bool isWoW = ToBool(::GetWinFlags()&0x4000);      // WoW box
  103.   return isWoW;
  104. }
  105.  
  106. //
  107. // Return true if the system is any version of windows 95
  108. //
  109. bool TSystem::IsWin95()
  110. {
  111.   static bool isWin95 = (GetVersion() >= 0x35F);
  112.   return isWin95;
  113. }
  114.  
  115. TSystem::TProcessor TSystem::GetProcessorType()
  116. {
  117.   // 386 CPUs do not have the alignment check (AC) bit (18), but 486s and above
  118.   // do
  119.   //
  120.   __asm {
  121.     db    0x66          // push extended flags (pushfd)
  122.     pushf
  123.     pop   ax            // read low word of flags
  124. //    and   ax, 0x0FFF    // clear IOPL bits
  125.     pop   dx            // read high word
  126.     or    dx, 0x0004    // set alignment check bit
  127.     push  dx
  128.     push  ax
  129.  
  130.     db    0x66          // pop extended flags
  131.     popf
  132.     db    0x66          // now re-push them
  133.     pushf
  134.  
  135.     pop   ax            // Get the flags,
  136.     pop   dx
  137.     test  dx, 0x0004    // and see if the AC bit stuck
  138.     jnz   Not386        // if so, then is newer that a 386
  139.   }
  140.   return Intel386;
  141.  
  142. Not386:
  143.   //  Check for the ability to set/clear the ID flag (bit 21) in EFLAGS
  144.   //  which diferentiates between Pentium (or greater) and the Intel486.
  145.   //
  146.   __asm {
  147.     db    0x66          // push extended flags (pushfd)
  148.     pushf
  149.     pop   ax            // read low word of flags
  150. //    and   ax, 0x0FFF    // clear IOPL bits
  151.     pop   dx            // read high word
  152.     or    dx, 0x0020    // set ID bit
  153.     push  dx
  154.     push  ax
  155.  
  156.     db    0x66          // pop extended flags
  157.     popf
  158.     db    0x66          // now re-push them
  159.     pushf
  160.  
  161.     pop   ax            // Get the flags,
  162.     pop   dx
  163.     test  dx, 0x0020    // and see if the ID flag bit stuck
  164.     jnz   Not486        // if so, then is newer that a 486
  165.   }
  166.   return Intel486;
  167.  
  168. Not486:
  169.   return IntelPentium;
  170. }
  171.  
  172. #endif
  173.  
  174. //
  175. // Get the windows version number in a 16bit unsigned int, with the bytes in
  176. // the correct order: major in high byte, minor in low byte. Uses older
  177. // GetVersion() API call.
  178. //
  179. uint TSystem::GetVersion() {
  180.   static uint version = uint( ((::GetVersion()&0xFF) << 8) |
  181.                               ((::GetVersion()&0xFF00) >> 8) );
  182.   return version;
  183. }
  184.  
  185. //
  186. // Get the windows version flags number in a 16bit unsigned int. This is the
  187. // high 16bits of the older GetVersion() API call.
  188. //
  189. uint TSystem::GetVersionFlags() {
  190.   static uint versionFlags = uint(::GetVersion() >> 16);
  191.   return versionFlags;
  192. }
  193.  
  194.